Information system developers are facing a much different competitive environment than in the recent past. Over the past several years, the emphasis has changed from data processing to management of information systems to decision support systems to strategic information systems. In order to keep up with changes in business, information developers must build systems which are flexible enough to adopt changes in business functions without at the same time incurring excessive maintenance and related costs.
Over the last twenty years or so, software development automation has progressed along three distinct and separate paths. One path pursued increased programming efficiency by automating program coding activities. The result was the development of non-procedural interpretive languages such as fourth generation languages (4GL) and program generators. The second path sought to achieve design effectiveness by bringing structure and rigor to analysis and design. The second path resulted in the development of structured methods of flowcharting programs or dividing programs into functional modules. More recently, automation of such structured methods has been achieved through computer aided software engineering ("CASE") graphic diagraming tools. The third path focused on reusability by taking a database approach to development using objects and data abstraction. This approach initially used a construct known as a data dictionary for accessing information about the data and the relationships among data elements. More recently, such techniques have comprised object-oriented systems and have incorporated so-called information resources dictionaries for storing and accessing objects, programs and data.
Because each of these paths and approaches has merits, there have been attempts made to integrate all of the different tools of the three different paths under the umbrella of information engineering. For example, there is an evolving ANSI standard for repository technology, and IBM has set forth "AD/Cycle," which defines methods to manage all information resources including application specification, programming tools, software programs, software program codes and data.
These approaches, however, do not resolve the problem of application program maintenance. Maintenance and other related support of computer software applications is often expensive, time consuming and unreliable. In order to eliminate maintenance cost, essentially one needs to eliminate application programs themselves. This would have the attendant benefit of reducing the information engineering application development cycle of specification, design, implementation and execution. Neither the three application development paths nor the integrated approaches described above adequately address the maintenance problem or how to solve it.
Another problem with prior art information processing systems relates to the detection of errors in the actions initiated by the application programs run by an application processing system. Prior art techniques focus on the fault arising from an action performing data processing operations and methods for correcting the fault or of continuing system operation despite the fault. However, in many application processing systems, the application program fault is not necessarily resident with the application program. These application programs performing the actions are well tested and implemented. The problem is that the application programs are not providing the expected behavior because an action which is supposed to occur is not occurring or some action occurs which is not supposed to occur.
These type of problems normally remain undetected until the application program breaks down or until poor performance is revealed due to unnecessary processing of actions. In a traditional system, the user must trace the processing flow and observe each action within the processing flow to analyze the performance of the system or to identify errors. Thus, it would be advantageous and very useful to have a system which conforms expected behavior or enforces specific behavior of each action of the application processing system and eliminates incorrect or unnecessary processing to optimize system performance.